/**
 * 水印处理工具类
 */
import { getApiKey, isApiKeyConfigured } from '@/config/api.js'

export default class WatermarkUtils {
  
  /**
   * 获取图片EXIF信息（简化版本）
   * @param {string} imagePath 图片路径
   * @returns {Promise} 返回EXIF信息
   */
  static async getImageExifSimple(imagePath) {
    return new Promise((resolve) => {
      console.log('使用简化版本获取EXIF，路径:', imagePath)
      
      // 直接返回默认EXIF信息，避免复杂的文件读取
      const defaultExif = this.getDefaultExifInfo()
      console.log('返回默认EXIF信息:', defaultExif)
      resolve(defaultExif)
    })
  }
  
  /**
   * 获取图片EXIF信息
   * @param {string} imagePath 图片路径
   * @returns {Promise} 返回EXIF信息
   */
  static async getImageExif(imagePath) {
    return new Promise((resolve, reject) => {
      console.log('开始获取EXIF信息，图片路径:', imagePath)
      
      const platform = uni.getSystemInfoSync().platform
      console.log('当前平台:', platform)
      
      if (platform === 'android') {
        // Android平台使用plus.io读取文件
        try {
          // 处理不同的路径格式
          let normalizedPath = imagePath
          
          // 移除file://前缀
          if (normalizedPath.startsWith('file://')) {
            normalizedPath = normalizedPath.replace('file://', '')
          }
          
          // 确保路径以/开头
          if (!normalizedPath.startsWith('/')) {
            normalizedPath = '/' + normalizedPath
          }
          
          console.log('标准化后的路径:', normalizedPath)
          
          // 检查plus对象是否可用
          if (typeof plus === 'undefined') {
            console.warn('plus对象不可用，返回默认EXIF信息')
            resolve(this.getDefaultExifInfo())
            return
          }
          
          // 尝试解析文件路径
          plus.io.resolveLocalFileSystemURL(normalizedPath, (entry) => {
            console.log('文件路径解析成功:', entry)
            
            entry.file((file) => {
              console.log('获取文件对象成功:', file)
              
              const reader = new plus.io.FileReader()
              
              reader.onloadend = (e) => {
                console.log('文件读取完成，数据大小:', e.target.result.byteLength)
                try {
                  const exif = this.parseExifData(e.target.result)
                  console.log('EXIF解析结果:', exif)
                  resolve(exif || this.getDefaultExifInfo())
                } catch (error) {
                  console.warn('解析EXIF失败:', error)
                  resolve(this.getDefaultExifInfo())
                }
              }
              
              reader.onerror = (error) => {
                console.warn('读取文件失败:', error)
                resolve(this.getDefaultExifInfo())
              }
              
              reader.readAsArrayBuffer(file)
            }, (fileError) => {
              console.warn('获取文件对象失败:', fileError)
              resolve(this.getDefaultExifInfo())
            })
          }, (resolveError) => {
            console.warn('解析文件路径失败:', resolveError)
            resolve(this.getDefaultExifInfo())
          })
          
        } catch (error) {
          console.error('EXIF获取过程中发生错误:', error)
          resolve(this.getDefaultExifInfo())
        }
      } else {
        // 非Android平台，返回默认信息
        console.log('非Android平台，返回默认EXIF信息')
        resolve(this.getDefaultExifInfo())
      }
    })
  }
  
  /**
   * 获取默认EXIF信息
   * @returns {object} 默认EXIF信息
   */
  static getDefaultExifInfo() {
    const now = new Date()
    return {
      time: {
        original: now.toISOString(),
        formatted: now.toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit'
        })
      },
      gps: {
        latitude: 39.9042,
        longitude: 116.4074,
        altitude: 50
      }
    }
  }

  /**
   * 解析EXIF数据
   * @param {ArrayBuffer} buffer 文件数据
   * @returns {object} EXIF信息
   */
  static parseExifData(buffer) {
    try {
      const view = new DataView(buffer)
      const exif = {}
      
      // 查找EXIF标记
      let offset = 0
      while (offset < buffer.byteLength - 2) {
        if (view.getUint16(offset) === 0xFFE1) {
          const exifLength = view.getUint16(offset + 2)
          const exifData = new DataView(buffer, offset + 4, exifLength - 2)
          
          // 解析GPS信息
          const gpsData = this.parseGPSData(exifData)
          if (gpsData) {
            exif.gps = gpsData
          }
          
          // 解析时间信息
          const timeData = this.parseTimeData(exifData)
          if (timeData) {
            exif.time = timeData
          }
          
          break
        }
        offset++
      }
      
      return exif
    } catch (error) {
      console.warn('EXIF解析错误:', error)
      return null
    }
  }

  /**
   * 解析GPS数据
   * @param {DataView} exifData EXIF数据
   * @returns {object} GPS信息
   */
  static parseGPSData(exifData) {
    try {
      // 简化的GPS解析，实际应用中可能需要更复杂的解析逻辑
      // 这里返回模拟的GPS数据
      return {
        latitude: 39.9042,
        longitude: 116.4074,
        altitude: 50
      }
    } catch (error) {
      return null
    }
  }

  /**
   * 解析时间数据
   * @param {DataView} exifData EXIF数据
   * @returns {object} 时间信息
   */
  static parseTimeData(exifData) {
    try {
      // 简化的时间解析，实际应用中需要从EXIF中提取
      // 这里返回当前时间作为默认值
      const now = new Date()
      return {
        original: now.toISOString(),
        formatted: now.toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit'
        })
      }
    } catch (error) {
      return null
    }
  }

  /**
   * 地理编码 - 将GPS坐标转换为地址
   * @param {number} latitude 纬度
   * @param {number} longitude 经度
   * @returns {Promise} 返回地址信息
   */
  static async geocode(latitude, longitude) {
    try {
      // 检查API密钥是否已配置
      if (!isApiKeyConfigured()) {
        console.warn('API密钥未配置，使用坐标信息')
        return {
          formatted_address: `${latitude.toFixed(4)}, ${longitude.toFixed(4)}`,
          address_component: null,
          pois: []
        }
      }

      // 使用高德地图API进行地理编码
      const response = await uni.request({
        url: 'https://restapi.amap.com/v3/geocode/regeo',
        method: 'GET',
        data: {
          key: getApiKey(),
          location: `${longitude},${latitude}`,
          output: 'json'
        },
        timeout: 10000
      })
      
      if (response.data && response.data.status === '1') {
        const result = response.data.regeocode
        return {
          formatted_address: result.formatted_address,
          address_component: result.addressComponent,
          pois: result.pois
        }
      } else {
        throw new Error('地理编码失败')
      }
    } catch (error) {
      console.warn('地理编码失败:', error)
      // 如果地理编码失败，返回坐标信息
      return {
        formatted_address: `${latitude.toFixed(4)}, ${longitude.toFixed(4)}`,
        address_component: null,
        pois: []
      }
    }
  }

  /**
   * 获取简化地址
   * @param {object} geocodeResult 地理编码结果
   * @returns {string} 简化地址
   */
  static getSimplifiedAddress(geocodeResult) {
    if (!geocodeResult || !geocodeResult.address_component) {
      return geocodeResult?.formatted_address || '未知位置'
    }
    
    const component = geocodeResult.address_component
    const parts = []
    
    // 添加城市信息
    if (component.city) {
      parts.push(component.city)
    } else if (component.province) {
      parts.push(component.province)
    }
    
    // 添加区县信息
    if (component.district) {
      parts.push(component.district)
    }
    
    // 添加街道信息
    if (component.street) {
      parts.push(component.street)
    }
    
    // 添加POI信息（如果有的话）
    if (geocodeResult.pois && geocodeResult.pois.length > 0) {
      const poi = geocodeResult.pois[0]
      if (poi.name) {
        parts.push(poi.name)
      }
    }
    
    return parts.length > 0 ? parts.join(' ') : geocodeResult.formatted_address
  }

  /**
   * 生成默认水印文字
   * @param {object} exifInfo EXIF信息
   * @returns {Promise<string>} 默认水印文字
   */
  static async generateDefaultWatermark(exifInfo = null) {
    console.log('开始生成默认水印文字，EXIF信息:', exifInfo)
    
    let watermarkText = ''
    
    try {
      if (exifInfo && exifInfo.time) {
        // 添加时间信息
        watermarkText += exifInfo.time.formatted
        console.log('使用EXIF时间信息:', exifInfo.time.formatted)
      } else {
        // 如果没有时间信息，使用当前时间
        const now = new Date()
        const timeString = now.toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit'
        })
        watermarkText += timeString
        console.log('使用当前时间:', timeString)
      }
      
      if (exifInfo && exifInfo.gps) {
        // 添加位置信息
        try {
          console.log('开始获取地理位置信息...')
          const geocodeResult = await this.geocode(exifInfo.gps.latitude, exifInfo.gps.longitude)
          const address = this.getSimplifiedAddress(geocodeResult)
          watermarkText += `\n${address}`
          console.log('地理位置信息获取成功:', address)
        } catch (error) {
          console.warn('获取地址失败:', error)
          // 如果获取地址失败，使用坐标
          const coordString = `${exifInfo.gps.latitude.toFixed(4)}, ${exifInfo.gps.longitude.toFixed(4)}`
          watermarkText += `\n${coordString}`
          console.log('使用坐标信息:', coordString)
        }
      } else {
        console.log('没有GPS信息，跳过位置信息')
      }
      
      const finalText = watermarkText || '水印文字'
      console.log('生成的默认水印文字:', finalText)
      return finalText
      
    } catch (error) {
      console.error('生成默认水印文字时发生错误:', error)
      // 返回基础水印文字
      const now = new Date()
      const timeString = now.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit'
      })
      return timeString
    }
  }

  /**
   * 获取默认水印设置
   * @returns {object} 默认水印设置
   */
  static getDefaultWatermarkSettings() {
    return {
      text: '水印文字',
      position: 'bottom-left', // 默认左下角
      fontSize: 20,
      color: '#ffffff', // 默认白色
      opacity: 0.7,
      rotation: 0,
      padding: 15
    }
  }

  /**
   * 计算水印位置
   * @param {string} position 位置类型
   * @param {number} canvasWidth 画布宽度
   * @param {number} canvasHeight 画布高度
   * @param {number} textWidth 文字宽度
   * @param {number} textHeight 文字高度
   * @param {number} padding 边距
   * @returns {object} {x, y} 坐标
   */
  static calculatePosition(position, canvasWidth, canvasHeight, textWidth, textHeight, padding = 20) {
    let x, y
    
    switch (position) {
      case 'top-left':
        x = padding
        y = padding + textHeight
        break
      case 'top-center':
        x = (canvasWidth - textWidth) / 2
        y = padding + textHeight
        break
      case 'top-right':
        x = canvasWidth - textWidth - padding
        y = padding + textHeight
        break
      case 'center-left':
        x = padding
        y = (canvasHeight + textHeight) / 2
        break
      case 'center':
        x = (canvasWidth - textWidth) / 2
        y = (canvasHeight + textHeight) / 2
        break
      case 'center-right':
        x = canvasWidth - textWidth - padding
        y = (canvasHeight + textHeight) / 2
        break
      case 'bottom-left':
        x = padding
        y = canvasHeight - padding
        break
      case 'bottom-center':
        x = (canvasWidth - textWidth) / 2
        y = canvasHeight - padding
        break
      case 'bottom-right':
        x = canvasWidth - textWidth - padding
        y = canvasHeight - padding
        break
      default:
        x = padding
        y = canvasHeight - padding
    }
    
    return { x, y }
  }
  
  /**
   * 绘制简单水印（用于测试）
   * @param {object} ctx Canvas上下文
   * @param {string} text 水印文字
   * @param {object} options 水印选项
   */
  static drawSimpleWatermark(ctx, text, options = {}) {
    const {
      fontSize = 20,
      color = '#ffffff',
      opacity = 0.7,
      padding = 15
    } = options
    
    console.log('开始绘制简单水印:', { text, fontSize, color, opacity })
    
    try {
      // 设置字体样式
      ctx.setFontSize(fontSize)
      ctx.setFillStyle(color)
      ctx.setGlobalAlpha(opacity)
      
      // 简单绘制在左下角
      ctx.fillText(text || '水印', padding, 300 - padding)
      
      console.log('简单水印绘制完成')
      
    } catch (error) {
      console.error('绘制简单水印失败:', error)
    }
  }
  
  /**
   * 绘制水印到画布
   * @param {object} ctx Canvas上下文
   * @param {string} text 水印文字
   * @param {object} options 水印选项
   */
  static drawWatermark(ctx, text, options = {}) {
    const {
      position = 'bottom-left',
      fontSize = 20,
      color = '#ffffff',
      opacity = 0.7,
      rotation = 0,
      padding = 15,
      canvasWidth = 300,
      canvasHeight = 300
    } = options
    
    console.log('开始绘制水印:', { text, position, fontSize, color, opacity, rotation })
    
    try {
      // 设置字体样式
      ctx.setFontSize(fontSize)
      ctx.setFillStyle(color)
      ctx.setGlobalAlpha(opacity)
      
      // 处理多行文字
      const lines = text.split('\n')
      const lineHeight = fontSize * 1.2
      
      console.log('水印文字行数:', lines.length)
      
      lines.forEach((line, index) => {
        try {
          // 获取文字尺寸 - 添加错误处理
          let textWidth = 0
          try {
            const measureResult = ctx.measureText(line)
            textWidth = measureResult ? measureResult.width : line.length * fontSize * 0.6
            console.log(`第${index + 1}行文字宽度:`, textWidth)
          } catch (measureError) {
            console.warn('文字测量失败，使用估算宽度:', measureError)
            textWidth = line.length * fontSize * 0.6
          }
          
          const textHeight = fontSize
          
          // 计算位置 - 使用传入的Canvas尺寸
          const { x, y } = this.calculatePosition(
            position, 
            canvasWidth, 
            canvasHeight, 
            textWidth, 
            textHeight, 
            padding
          )
          
          console.log(`第${index + 1}行位置:`, { x, y })
          
          // 多行文字的垂直偏移
          const yOffset = index * lineHeight
          
          // 应用旋转
          if (rotation !== 0) {
            ctx.save()
            ctx.translate(x + textWidth / 2, y + yOffset - textHeight / 2)
            ctx.rotate(rotation * Math.PI / 180)
            ctx.fillText(line, -textWidth / 2, textHeight / 2)
            ctx.restore()
          } else {
            ctx.fillText(line, x, y + yOffset)
          }
          
          console.log(`第${index + 1}行绘制完成`)
          
        } catch (lineError) {
          console.error(`绘制第${index + 1}行失败:`, lineError)
        }
      })
      
      console.log('水印绘制完成')
      
    } catch (error) {
      console.error('绘制水印时发生错误:', error)
      // 尝试绘制简单的水印作为备用
      try {
        ctx.setFontSize(fontSize)
        ctx.setFillStyle(color)
        ctx.setGlobalAlpha(opacity)
        ctx.fillText(text || '水印', padding, canvasHeight - padding)
        console.log('备用水印绘制完成')
      } catch (fallbackError) {
        console.error('备用水印也失败:', fallbackError)
      }
    }
  }
  
  /**
   * 生成水印图片
   * @param {string} imagePath 原图路径
   * @param {string} text 水印文字
   * @param {object} options 水印选项
   * @returns {Promise} 返回生成的图片路径
   */
  static async generateWatermarkImage(imagePath, text, options = {}) {
    return new Promise((resolve, reject) => {
      // 获取图片信息
      uni.getImageInfo({
        src: imagePath,
        success: (imageInfo) => {
          // 创建画布
          const ctx = uni.createCanvasContext('tempCanvas')
          
          // 绘制原图
          ctx.drawImage(imagePath, 0, 0, imageInfo.width, imageInfo.height)
          
          // 绘制水印
          this.drawWatermark(ctx, text, options)
          
          // 生成图片
          ctx.draw(false, () => {
            uni.canvasToTempFilePath({
              canvasId: 'tempCanvas',
              success: (res) => {
                resolve(res.tempFilePath)
              },
              fail: reject
            })
          })
        },
        fail: reject
      })
    })
  }
  
  /**
   * 验证水印参数
   * @param {object} options 水印选项
   * @returns {object} 验证结果
   */
  static validateOptions(options) {
    const errors = []
    
    if (!options.text || options.text.trim() === '') {
      errors.push('水印文字不能为空')
    }
    
    if (options.fontSize && (options.fontSize < 8 || options.fontSize > 100)) {
      errors.push('字体大小应在8-100之间')
    }
    
    if (options.opacity && (options.opacity < 0 || options.opacity > 1)) {
      errors.push('透明度应在0-1之间')
    }
    
    if (options.rotation && (options.rotation < -180 || options.rotation > 180)) {
      errors.push('旋转角度应在-180到180度之间')
    }
    
    return {
      isValid: errors.length === 0,
      errors
    }
  }
  
  /**
   * 获取位置选项列表
   * @returns {array} 位置选项
   */
  static getPositionOptions() {
    return [
      { value: 'top-left', label: '左上', icon: '↖' },
      { value: 'top-center', label: '上中', icon: '↑' },
      { value: 'top-right', label: '右上', icon: '↗' },
      { value: 'center-left', label: '左中', icon: '←' },
      { value: 'center', label: '中心', icon: '●' },
      { value: 'center-right', label: '右中', icon: '→' },
      { value: 'bottom-left', label: '左下', icon: '↙' },
      { value: 'bottom-center', label: '下中', icon: '↓' },
      { value: 'bottom-right', label: '右下', icon: '↘' }
    ]
  }
  
  /**
   * 获取颜色选项列表
   * @returns {array} 颜色选项
   */
  static getColorOptions() {
    return [
      { value: '#ffffff', label: '白色' },
      { value: '#000000', label: '黑色' },
      { value: '#ff0000', label: '红色' },
      { value: '#00ff00', label: '绿色' },
      { value: '#0000ff', label: '蓝色' },
      { value: '#ffff00', label: '黄色' },
      { value: '#ff00ff', label: '紫色' },
      { value: '#00ffff', label: '青色' }
    ]
  }
} 